import org.w3c.dom.ls.LSOutput;

import java.util.Arrays;

public class Test7 {
    //1.数组的定义与使用
    int[] arry={1,2,3,4,5,6,7};
    int []arry1=new int[]{1,2,3,4,5,6,7};
    int []arry2=new int[]{10};//没有初始化
    boolean []gip=new boolean[3];//没有赋值默认为false
    //2.通过下标访问数组中的元素
    public static void main2(String[] args) {
        int []arry3=new int[]{1,2,3,4,5,6};
        System.out.println(arry3[3]);
    }
    //3.for循环遍历数组
    public static void main3(String[] args) {
        int []arry3=new int[]{1,2,3,4,4,5};
        for (int i = 0; i < arry3.length ; i++) {
            System.out.print(arry3[i]+"  ");
            }
        //4.用 for-each 遍历数组
        for(int x:arry3)//x数组的内rong,arry3变量名称{
            System.out.print(x+" ");
        }
//5.利用String ret= Arrays.toString(变量名)以字符串形式打印数组;
    public static void main5(String[] args) {
        int []arry3=new int[]{1,2,3,4,4,6};
        String ret= Arrays.toString(arry3);
        System.out.println(ret);
    }
    //6.求两个数的最大值
    public static int max(int a,int c){
        return a>c?a:c;
    }

    public static void main6(String[] args) {
        int ret=max(2,3);
        System.out.println(ret);
    }
    //7.求三个数的最大值
    public static int max(int a,int b,int c){
        int max2=max(a,b);
        int ret1=max(max2,c);
        return ret1;
    }

    public static void main7(String[] args) {
        int ret=max(3,4,5);
        System.out.println(ret);
    }

    public static void main77(String[] args) {
        int[]arrry=new int[]{1,2,3,4,5,6,7};//arrry是局部变量也是引用变量，会在栈里开辟一段内存存储的是对象的内存地址，而非对象本身。
    }                                             // 堆里面开辟一段内存存储的是对象，通过arrry这个引用来指向对象。
    //8.两个引用指向一个对象
    public static void main8(String[] args) {
        int[]arry=new int[]{1,2,3};
        arry[0]=100;
        arry[1]=200;
        int[]arry1=new int[]{6,7,3,4,5};
        arry1[2]=300;
        arry1[3]=400;
        arry1[4]=500;
        arry=arry1;//(把arry1的值给arry）arry引用变量存储的地址等于了arry1引用变量存储的地址，共同指向了arry1引用变量所指的对象
        String ret=Arrays.toString(arry1);//当两个引用共同指向一个对象的时候，通过任何一个引用都能修改对象的值
        System.out.println(ret);
    }
    //9.null不指向任何对象 NullPointerException.（空指针异常）
    public static void main9(String[] args) {
        int[] arr = null;
        System.out.println(arr.length);
    }
    //10.将数组扩大二倍
    //fac方法创建了一个新数组ret，将原数组arry的每个元素乘以 2 后存入新数组，最后返回新数组。原数组arry的内容没有被修改。
    public static double[] fac(double[]arry){
        double [] ret=new double[arry.length];
        for (int i = 0; i <arry.length ; i++) {
                ret[i]=arry[i]*2;
        }
        return ret;//函数结束，回收局部变量（形参arry；ret）的内存
    }

    public static void main10(String[] args) {
        double[]arry=new double[]{1.12,1.13,1.44};
        double[]damp=fac(arry);
        System.out.println(Arrays.toString(damp));
        System.out.println(Arrays.toString((arry)));
    }
    //11.在数组本身扩大二倍
    public static void fac2(int[]arry){
        for (int i = 0; i <arry.length ; i++) {
            arry[i]=arry[i]*2;
        }
    }
    public static void main11(String[] args) {
        int[]arry=new int[]{1,2,3};
        fac2(arry);
        System.out.println(Arrays.toString(arry));
    }
    //12.一个引用不能指向两个对象；
    public static void  fac(int[]arry){
        arry[0]=1;
    }

    public static void main122(String[] args) {
        int []arry=new int[]{2,3,6};
        fac(arry);
        System.out.println(Arrays.toString(arry));
    }
    //12.1局部变量被jvm回收了
    public static void fac3(int[]arry1){
        int []arry2=new int[]{987,654};
    }
    public static void main12(String[] args) {
        int []arry2=new int[]{2,3,6};
        fac3(arry2);
        System.out.println(Arrays.toString(arry2));
    }
    //13.通过Arrays.sort(变量名)进行大小排序;
    public static void main13(String[] args) {
        int []arry=new int[]{8,3,5,9};
        Arrays.sort(arry);
        System.out.println(Arrays.toString(arry));
    }
    //14.通过 int 自定义变量名=Arrays.binarySearch（数组名，下标范围起始点，下标范围终止点，要找的元素）寻找要找的元素下标。
    //    public static void main(String[] args) {）
    public static void main14(String[] args) {
        int []arry=new int[]{8,3,5,9};
     int xiabiao=   Arrays.binarySearch(arry, 1,2,3 );
        System.out.println(xiabiao);
    }
    //15.冒泡排序
    public static void q(int []w){
        for (int i = 0; i < w.length-1; i++) {          //外层循环控制趟数
            for (int j = 0; j < w.length-1-i; j++) {        //内层循环控制比较次数
                if (w[j]>w[j+1]){
                    int tamp=w[j];
                    w[j]=w[j+1];
                    w[j+1]=tamp;
                  /* 交换两个变量
                   int temp = a;  // 保存 a 的值
                    a = b;         // a 现在等于 b
                    b = temp;      // b 现在等于原来的 a*/
                }
            }
        }
    }

    public static void main15(String[] args) {
        int[]w=new int[]{3,6,1,2,9};
        q(w);
        System.out.println(Arrays.toString(w));
    }
    //16.数组的拷贝
    public static int[] copyarry(int[]arry){
        int []copy=new int[arry.length];
        for (int i = 0; i < arry.length; i++) {
            copy[i]=arry[i];
        }
        return copy;
    }

    public static void main16(String[] args) {
            int[]arry=new int[]{1,2,5,8,9};
           int[] copy= copyarry(arry);
        System.out.println(Arrays.toString(copy));
    }
    //16.java快速拷贝  创建一个新数组=Arrays.copyOf(需要拷贝的数组变量名,需要拷贝的数组变量名.length*2（可以对拷贝的数组进行扩容);
    //.java快速拷贝 选择拷贝范围int []copy1=Arrays.copyOfRange(arry,1,3);
    public static void main166(String[] args) {
        int[]arry=new int[]{2,7,0,3};
        int []copy=Arrays.copyOf(arry,arry.length*2);
        int []copy1=Arrays.copyOfRange(arry,1,3);

        System.out.println(Arrays.toString(copy));
    }
    //17.数组填充 Arrays.fill(数组名，填充内容)
    //   数组填充 Arrays.fill(数组名，下标范围，下标范围，填充内容)
    public static void main17(String[] args) {
        int[]tian=new int[7];
        Arrays.fill(tian,4);
        Arrays.fill(tian,1,3,2  );
        System.out.println(Arrays.toString(tian));
    }
    //18.二维数组的表示
    public static void main18(String[] args) {
        int[][]ary={{1,3,5},{2,4,6}};//两行三列
        int[][]ary1=new int[][]{{1,3,5},{2,4,6}};
        int[][]ary2=new int[2][3];
    }
        //18.2二维数组的打印for循环
    public static void main188(String[] args) {
        int[][]ary={{1,3,5},{2,4,6}};//两行三列
        for (int i = 0; i < 2; i++) {//代表行
            for (int j = 0; j < 3; j++) {//代表列
                System.out.print(ary[i][j]+" ");
            }
            System.out.println();
        }
    }
    //18.2二维数组本质上也就是一维数组
    public static void main1888(String[] args) {
        int[][]ary={{1,3,5},{2,4,6}};
        System.out.println(ary.length);//行数
        System.out.println(ary[0].length);//每行有几列
        System.out.println(ary[1].length);//每行有几列
        for (int i = 0; i < ary.length; i++) {
            for (int j = 0; j <ary[i].length ; j++) {
                System.out.print(ary[i][j]+" ");//打印数组内容
            }
            System.out.println();
        }
        System.out.println(Arrays.toString(ary[0]));//打印数组
        System.out.println(Arrays.toString(ary[1]));
    }
    //19.用 for-each 遍历二维数组
            // for(int x:arry3)//x数组的内rong,arry3变量名称{
           //int []arry3=new int[]{1,2,3,4,4,5};
          //  System.out.print(x+" ");

    public static void main19(String[] args) {
        int[][]ary={{1,3,5},{2,4,6}};
        for(int[]ary1:ary){
            //int[]ary1遍历二维数组的每一行
            // 第一次循环：ary1 = {1, 3, 5}
            // 第二次循环：ary1 = {2, 4, 6}
            for(int x:ary1){
                // 遍历当前行中的每个元素
                System.out.print(x+" " );
            }
            System.out.println();//每次循环后换行
        }
    }
    //20.深度打印二维数组以字符串形式(更简单快捷)利用String ret= Arrays.deepToString(变量名)以字符串形式打印数组
    public static void main(String[] args) {
        int [][]ary=new int[][]{{12,3,4},{23,5,8}};
        String ret=Arrays.deepToString(ary);
        System.out.println(ret);
    }
}
